package org.example.projecttwo.controller.content;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import org.example.projecttwo.common.Result;
import org.example.projecttwo.entity.LikeRecord;
import org.example.projecttwo.entity.dto.content.request.LikeDTO;
import org.example.projecttwo.service.ILikeRecordService;
import org.example.projecttwo.service.Iuser.IUserStatisticsService;
import org.example.projecttwo.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/likes")
@Tag(name = "点赞管理", description = "点赞记录管理")
public class LikeController {

    @Autowired
    private ILikeRecordService likeRecordService;

    @Autowired
    private IUserStatisticsService userStatisticsService;

    @Autowired
    private BaseService baseService;

    /**
     * 查询用户点赞记录
     * 支持按内容类型筛选（1-文章，2-新闻，3-评论）
     */
    @GetMapping("/user")
    @Operation(summary = "查询用户点赞记录", description = "查询指定用户的点赞记录 -- 点赞管理")
    public Result<List<LikeRecord>> getUserLikes(
            @Parameter(description = "用户ID", required = true) @RequestParam Long userId,
            @Parameter(description = "内容类型（1-文章，2-新闻，3-评论）") @RequestParam(required = false) Integer contentType) {
        List<LikeRecord> likes = likeRecordService.getUserLikes(userId, contentType);
        return Result.success(likes);
    }

    /**
     * 查询内容的所有点赞记录
     */
    @GetMapping("/content")
    @Operation(summary = "查询内容点赞记录", description = "查询指定内容的所有点赞记录 -- 点赞管理")
    public Result<List<LikeRecord>> getContentLikes(
            @Parameter(description = "内容类型（1-文章，2-新闻，3-评论）", required = true) @RequestParam Integer contentType,
            @Parameter(description = "内容ID", required = true) @RequestParam Long contentId) {
        // 验证内容类型合法性
        if (contentType < 1 || contentType > 3) {
            return Result.error("内容类型无效，仅支持1（文章）、2（新闻）或3（评论）");
        }
        List<LikeRecord> likes = likeRecordService.getContentLikes(contentType, contentId);
        return Result.success(likes);
    }

    /**
     * 添加点赞
     * 同时更新用户获赞统计和内容点赞数
     */
    @PostMapping
    @Operation(summary = "添加点赞", description = "添加点赞记录，同时更新相关统计 -- 点赞管理")
    public Result<LikeRecord> addLike(@Valid @RequestBody LikeDTO dto) {
        // 验证内容类型
        if (dto.getContentType() < 1 || dto.getContentType() > 3) {
            return Result.error("内容类型无效，仅支持1（文章）、2（新闻）或3（评论）");
        }

        // 检查是否已点赞
        if (likeRecordService.checkLike(dto.getUserId(), dto.getContentType(), dto.getContentId())) {
            return Result.error("已点赞，无需重复操作");
        }

        // 添加点赞记录并更新统计
        LikeRecord like = likeRecordService.addLike(dto.getUserId(), dto.getContentType(), dto.getContentId());
        return Result.success(like);
    }

    /**
     * 取消点赞
     * 同时更新用户获赞统计和内容点赞数
     */
    @DeleteMapping
    @Operation(summary = "取消点赞", description = "取消点赞记录，同时更新相关统计 -- 点赞管理")
    public Result<String> cancelLike(@Valid @RequestBody LikeDTO dto) {
        // 验证内容类型
        if (dto.getContentType() < 1 || dto.getContentType() > 3) {
            return Result.error("内容类型无效，仅支持1（文章）、2（新闻）或3（评论）");
        }

        // 检查是否已点赞
        if (!likeRecordService.checkLike(dto.getUserId(), dto.getContentType(), dto.getContentId())) {
            return Result.error("未点赞，无法取消");
        }

        // 取消点赞并更新统计
        likeRecordService.cancelLike(dto.getUserId(), dto.getContentType(), dto.getContentId());
        return Result.success("取消点赞成功");
    }

    /**
     * 检查用户是否已点赞指定内容
     */
    @GetMapping("/check")
    @Operation(summary = "检查是否点赞", description = "检查用户是否已点赞指定内容 -- 点赞管理")
    public Result<Boolean> checkLike(
            @Parameter(description = "用户ID", required = true) @RequestParam Long userId,
            @Parameter(description = "内容类型（1-文章，2-新闻，3-评论）", required = true) @RequestParam Integer contentType,  // 修改描述
            @Parameter(description = "内容ID", required = true) @RequestParam Long contentId) {
        // 验证内容类型
        if (contentType < 1 || contentType > 3) {
            return Result.error("内容类型无效，仅支持1（文章）、2（新闻）或3（评论）");
        }

        boolean isLiked = likeRecordService.checkLike(userId, contentType, contentId);
        return Result.success(isLiked);
    }

    /**
     * 批量取消点赞
     * 用于用户批量取消自己的点赞记录
     */
    @PostMapping("/batch-delete")
    @Operation(summary = "批量取消点赞", description = "批量取消用户的点赞记录，同时更新统计 -- 点赞管理")
    public Result<String> batchCancelLikes(
            @Parameter(description = "用户ID", required = true) @RequestParam Long userId,
            @Parameter(description = "点赞记录列表", required = true) @RequestBody List<LikeDTO> likeList) {
        if (likeList == null || likeList.isEmpty()) {
            return Result.error("请选择至少一条点赞记录");
        }

        // 验证列表中所有记录的用户ID是否与请求参数一致
        boolean hasInvalid = likeList.stream()
                .anyMatch(dto -> !dto.getUserId().equals(userId) ||
                        (dto.getContentType() < 1 || dto.getContentType() > 3));
        if (hasInvalid) {
            return Result.error("批量操作包含无效数据，请检查（内容类型仅支持1-3）");
        }

        likeRecordService.batchCancelLikes(userId, likeList);
        return Result.success("批量取消点赞成功,共" + likeList.size() + "条");
    }

    /**
     * 获取内容的点赞数量
     */
    @GetMapping("/count")
    @Operation(summary = "获取内容点赞数", description = "统计指定内容的点赞数量 -- 点赞管理")
    public Result<Integer> getLikeCount(
            @Parameter(description = "内容类型（1-文章，2-新闻，3-评论）", required = true) @RequestParam Integer contentType,  // 修改描述
            @Parameter(description = "内容ID", required = true) @RequestParam Long contentId) {
        // 验证内容类型
        if (contentType < 1 || contentType > 3) {
            return Result.error("内容类型无效，仅支持1（文章）、2（新闻）或3（评论）");
        }

        int count = likeRecordService.countByContent(contentType, contentId);
        return Result.success(count);
    }

    /**
     * 获取当前登录用户的点赞记录
     * 用于个人中心展示
     */
    @GetMapping("/current-user")
    @Operation(summary = "获取当前用户点赞记录", description = "查询当前登录用户的所有点赞记录 -- 个人中心")
    public Result<List<LikeRecord>> getCurrentUserLikes(
            @Parameter(description = "内容类型（1-文章，2-新闻，3-评论，空表示全部）") @RequestParam(required = false) Integer contentType) {  // 修改描述
        Long currentUserId = baseService.getCurrentUserId();
        List<LikeRecord> likes = likeRecordService.getUserLikes(currentUserId, contentType);
        return Result.success(likes);
    }
}